Como posso remover um item específico de uma matriz?

1
2
3
4
Próximo
Encontre o índice do elemento da matriz que deseja remover usando indexOf e remova esse índice com splice.
O método splice () altera o conteúdo de uma matriz removendo
elementos existentes e / ou adição de novos elementos.
matriz const = [2, 5, 9];
console.log (array);
índice const = array.indexOf (5);
if (índice> -1) {
array.splice (índice, 1);
}
// array = [2, 9]
console.log (array);
O segundo parâmetro de emenda é o número de elementos a serem removidos. Observe que splice modifica a matriz no local e retorna uma nova matriz contendo os elementos que foram removidos.
Para fins de integridade, aqui estão as funções. A primeira função remove apenas uma única ocorrência (ou seja, remove a primeira correspondência de 5 de [2,5,9,1,5,8,5]), enquanto a segunda função remove todas as ocorrências:
function removeItemOnce (arr, value) {
índice var = arr.indexOf (valor);
if (índice> -1) {
arr.splice (índice, 1);
}
return arr;
}
function removeItemAll (arr, value) {
var i = 0;
while (i  = 0; i--) {
if (matriz [i] === número) {
array.splice (i, 1);
}
}
Se você apenas deseja que o elemento no índice i não exista mais, mas não deseja que os índices dos outros elementos mudem:
delete array [i];
|
Editado em outubro de 2016
Faça de forma simples, intuitiva e explícita (navalha de Occam)
Faça imutável (a matriz original permanece inalterada)
Faça isso com funções JavaScript padrão, se o seu navegador não as suportar - use polyfill
Neste exemplo de código, eu uso a função "array.filter (...)" para remover itens indesejados de uma matriz. Esta função não altera o array original e cria um novo. Se o seu navegador não suporta esta função (por exemplo, Internet Explorer antes da versão 9 ou Firefox antes da versão 1.5), considere usar o filtro polyfill da Mozilla.
Removendo item (código ECMA-262 Edição 5, também conhecido como JavaScript antigo)
valor var = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (função (item) {
item de retorno! == valor
})
console.log (arr)
// [1, 2, 4, 5]
Removendo item (código ECMAScript 6)
deixe valor = 3
deixe arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == valor)
console.log (arr)
// [1, 2, 4, 5]
IMPORTANTE ECMAScript 6 "() => {}" sintaxe da função de seta não é suportada no Internet Explorer, Chrome antes da versão 45, Firefox antes da versão 22 e Safari antes da versão 10. Para usar a sintaxe ECMAScript 6 em navegadores antigos, você pode usar o BabelJS.
Removendo vários itens (código ECMAScript 7)
Uma vantagem adicional deste método é que você pode remover vários itens
deixe forDeletion = [2, 3, 5]
deixe arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.includes (item))
// !!! Leia abaixo sobre o suporte array.includes (...) !!!
console.log (arr)
// [1, 4]
IMPORTANTE A função "array.includes (...)" não é suportada no Internet Explorer, Chrome antes da versão 47, Firefox antes da versão 43, Safari antes da versão 9 e Edge antes da versão 14, então aqui está polyfill da Mozilla.
Removendo vários itens (no futuro, talvez)
Se a proposta "This-Binding Syntax" for aceita, você poderá fazer o seguinte:
// array-lib.js
export function remove (... forDeletion) {
return this.filter (item =>! forDeletion.includes (item))
}
// main.js
import {remove} de './array-lib.js'
deixe arr = [1, 2, 3, 4, 5, 3]
// :: Proposta de sintaxe desta ligação
// usando a função "remover" como "método virtual"
// sem estender Array.prototype
arr = arr :: remover (2, 3, 5)
console.log (arr)
// [1, 4]
Experimente você mesmo no BabelJS :)
Referência
Array.prototype.includes
Composição funcional
|
Depende se você deseja manter um espaço vazio ou não.
Se você quiser um slot vazio:
matriz [índice] = indefinido;
Se você não quiser um slot vazio:
// Para manter o original:
// oldArray = [... array];
// Isso modifica o array.
array.splice (índice, 1);
E se você precisar do valor desse item, pode apenas armazenar o elemento da matriz retornada:
valor var = array.splice (índice, 1) [0];
Se você quiser remover uma das extremidades do array, pode usar array.pop () para o último ou array.shift () para o primeiro (ambos retornam o valor do item também).
Se você não souber o índice do item, pode usar array.indexOf (item) para obtê-lo (em um if () para obter um item ou em um tempo () para obter todos eles). array.indexOf (item) retorna o índice ou -1 se não for encontrado.
|
Um amigo estava tendo problemas no Internet Explorer 8 e me mostrou o que fazia. Eu disse a ele que estava errado, e ele me disse que tinha a respostaaqui. A resposta principal atual não funcionará em todos os navegadores (Internet Explorer 8, por exemplo) e removerá apenas a primeira ocorrência do item.
Remova TODAS as instâncias de uma matriz
função array_remove_index_by_value (arr, item)
{
para (var i = arr.length; i--;)
{
if (arr [i] === item) {arr.splice (i, 1);}
}
}
Ele percorre a matriz de trás para frente (já que os índices e o comprimento mudarão conforme os itens são removidos) e remove o item se for encontrado. Funciona em todos os navegadores.
|
Existem duas abordagens principais:
splice (): umArray.splice (índice, 1);
deletar: deletar umArray [índice];
Tenha cuidado ao usar delete para uma matriz. É bom para excluir atributos de objetos, mas não tão bom para arrays. É melhor usar a emenda para matrizes.
Lembre-se de que, ao usar delete para um array, você pode obter resultados errados para anArray.length. Em outras palavras, delete removeria o elemento, mas não atualizaria o valor da propriedade length.
Você também pode esperar ter buracos nos números de índice após usar delete, por exemplo, você pode acabar tendo os índices 1, 3, 4, 8, 9 e 11 e o tamanho que tinha antes de usar delete. Nesse caso, todos os loops for indexados travariam, uma vez que os índices não são mais sequenciais.
Se você for forçado a usar delete por algum motivo, você deve usar para cada loops quando precisar fazer um loop em arrays. Na verdade, sempre evite usar loops for indexados, se possível. Dessa forma, o código seria mais robusto e menos sujeito a problemas com índices.
|
Array.prototype.remove_by_value = function (val) {
para (var i = 0; i  row.id === 5);
var removido = helper.remove (arr, row => row.name.startsWith ('BMW'));
##Definição
var helper = {
// Remova e retorne a primeira ocorrência
removeOne: function (array, predicate) {
para (var i = 0; i  [2, 3, 4]
|
Você pode usar ES6. Por exemplo, para excluir o valor '3' neste caso:
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((valor) => valor! = '3');
console.log (newArray);
Resultado :
["1", "2", "4", "5", "6"]
|
Se você quiser uma nova matriz com as posições excluídas removidas, você sempre pode excluir o elemento específico e filtrar a matriz. Pode ser necessária uma extensão do objeto array para navegadores que não implementam o método de filtro, mas a longo prazo é mais fácil, pois tudo que você faz é o seguinte:
var my_array = [1, 2, 3, 4, 5, 6];
delete my_array [4];
console.log (my_array.filter (function (a) {return typeof a! == 'undefined';}));
Deve exibir [1, 2, 3, 4, 6].
|
Aqui estão algumas maneiras de remover um item de uma matriz usando JavaScript.
Todos os métodos descritos não alteram o array original e, em vez disso, criam um novo.
Se você conhece o índice de um item
Suponha que você tenha uma matriz e queira remover um item da posição i.
Um método é usar slice ():
itens const = ['a', 'b', 'c', 'd', 'e', ​​'f']
const i = 3
const filterItems = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (filterItems)
slice () cria um novo array com os índices que recebe. Simplesmente criamos um novo array, do início ao índice que queremos remover, e concatenamos outro array da primeira posição após aquele que removemos até o final do array.
Se você sabe o valor
Nesse caso, uma boa opção é usar filter (), que oferece uma abordagem mais declarativa:
itens const = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
const filterItems = items.filter (item => item! == valueToRemove)
console.log (filterItems)
Isso usa as funções de seta ES6. Você pode usar as funções tradicionais para oferecer suporte a navegadores mais antigos:
itens const = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
const filterItems = items.filter (function (item) {
return item! == valueToRemove
})
console.log (filterItems)
ou você pode usar o Babel e transpilar o código ES6 de volta para o ES5 para torná-lo mais digerível para navegadores antigos e, ainda assim, escrever JavaScript moderno em seu código.
Removendo vários itens
E se, em vez de um único item, você quiser remover muitos itens?
Vamos encontrar a solução mais simples.
Por índice
Você pode simplesmente criar uma função e remover itens em série:
itens const = ['a', 'b', 'c', 'd', 'e', ​​'f']
const removeItem = (items, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
let filterItems = removeItem (items, 3)
filterItems = removeItem (filterItems, 5)
// ["a", "b", "c", "d"]
console.log (filterItems)
Por valor
Você pode pesquisar a inclusão dentro da função de retorno de chamada:
itens const = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valuesToRemove = ['c', 'd']
const filterItems = items.filter (item =>! valuesToRemove.includes (item))
// ["a", "b", "e", "f"]
console.log (filterItems)
Evite transformar a matriz original
splice () (não deve ser confundido com slice ()) altera o array original e deve ser evitado.
(postado originalmente em meu site https://flaviocopes.com/how-to-remove-item-from-array/)
|
Confira este código. Funciona em todos os principais navegadores.
remove_item = function (arr, value) {
var b = '';
para (b em arr) {
if (arr [b] === valor) {
arr.splice (b, 1);
pausa;
}
}
return arr;
};
Chame esta função
remove_item (array, valor);
|
ES6 e sem mutação: (outubro de 2016)
const removeByIndex = (lista, índice) =>
[
... list.slice (0, índice),
... list.slice (índice + 1)
];
output = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (saída)
|
Você pode usar lodash _.pull (mutate array), _.pullAt (mutate array) ou _.without (não mutate array),
var array1 = ['a', 'b', 'c', 'd']
_.pull (matriz1, 'c')
console.log (array1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (matriz2, 0)
console.log (array2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (array3, 'i') // ['j', 'k', 'l']
console.log (array3) // ['i', 'j', 'k', 'l']
|
A remoção de um determinado elemento / string de uma matriz pode ser feita em uma linha:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
Onde:
theArray: a matriz da qual você deseja remover algo específico
stringToRemoveFromArray: a string que você deseja remover e 1 é a quantidade de elementos que deseja remover.
NOTA: Se "stringToRemoveFromArray" não for localizado na matriz, isso removerá o último elemento da matriz.
É sempre uma boa prática verificar se o elemento existe em seu array antes de removê-lo.
if (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Se você tiver acesso a versões mais recentes do Ecmascript nos computadores do seu cliente (AVISO, pode não funcionar em estações mais antigas):
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((valor) => valor! = '3');
Onde '3' é o valor que você deseja remover da matriz.
A matriz então se tornaria: ['1', '2', '4', '5', '6']
|
OK, por exemplo, você tem a matriz abaixo:
var num = [1, 2, 3, 4, 5];
E queremos excluir o número 4. Você pode simplesmente usar o código abaixo:
num.splice (num.indexOf (4), 1); // num será [1, 2, 3, 5];
Se você estiver reutilizando esta função, você escreve uma função reutilizável que será anexada à função de matriz nativa como abaixo:
Array.prototype.remove = Array.prototype.remove || função (x) {
const i = this.indexOf (x);
if (i === - 1)
Retorna;
this.splice (i, 1); // num.remove (5) === [1, 2, 3];
}
Mas e se você tiver o array abaixo, em vez de alguns [5] s no array?
var num = [5, 6, 5, 4, 5, 1, 5];
Precisamos de um loop para verificar todos eles, mas uma maneira mais fácil e eficiente é usar funções JavaScript integradas, então escrevemos uma função que usa um filtro como abaixo:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]
Além disso, existem bibliotecas de terceiros que ajudam você a fazer isso, como Lodash ou Underscore. Para obter mais informações, consulte lodash _.pull, _.pullAt ou _.without.
|
atuação
Hoje (09-12-2019), realizo testes de desempenho no macOS v10.13.6 (High Sierra) para as soluções escolhidas. Mostro delete (A), mas não o uso em comparação com outros métodos, pois deixou um espaço vazio no array.
As conclusões
a solução mais rápida é array.splice (C) (exceto Safari para pequenos arrays onde ocorre pela segunda vez)
para grandes arrays, array.slice + splice (H) é a solução imutável mais rápida para Firefox e Safari; Array.from (B) é mais rápido no Chrome
soluções mutáveis ​​são geralmente 1,5x-6x mais rápidas do que imutáveis
para tabelas pequenas no Safari, surpreendentemente, a solução mutável (C) é mais lenta do que a solução imutável (G)
Detalhes
Nos testes, removo o elemento do meio do array de maneiras diferentes. As soluções A, C estão implementadas. As soluções B, D, E, F, G, H são imutáveis.
Resultados para matriz com 10 elementos
No Chrome, o array.splice (C) é a solução mais rápida no local. O array.filter (D) é a solução imutável mais rápida. O mais lento é array.slice (F). Você pode realizar o teste em sua máquina aqui.
Resultados para matriz com 1.000.000 de elementos
No Chrome, o array.splice (C) é a solução mais rápida no local (o delete (C) é semelhante rápido - mas deixou um slot vazio no array (portanto, não executa uma 'remoção completa')). O array.slice-splice (H) é a solução imutável mais rápida. O mais lento é array.filter (D e E). Você pode realizar o teste em sua máquina aqui.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letra, matriz) => console.log (letra, matriz.join `,`);
function A (array) {
índice var = array.indexOf (5);
delete array [índice];
log ('A', array);
}
função B (matriz) {
índice var = array.indexOf (5);
var arr = Array.from (array);
arr.splice (índice, 1)
log ('B', arr);
}
função C (matriz) {
índice var = array.indexOf (5);
array.splice (índice, 1);
log ('C', array);
}
função D (matriz) {
var arr = array.filter (item => item! == 5)
log ('D', arr);
}
função E (matriz) {
índice var = array.indexOf (5);
var arr = array.filter ((item, i) => i! == index)
log ('E', arr);
}
função F (matriz) {
índice var = array.indexOf (5);
var arr = array.slice (0, índice) .concat (array.slice (índice + 1))
log ('F', arr);
}
função G (matriz) {
índice var = array.indexOf (5);
var arr = [... matriz.slice (0, índice), ... matriz.slice (índice + 1)]
log ('G', arr);
}
function H (array) {
índice var = array.indexOf (5);
var arr = array.slice (0);
arr.splice (índice, 1);
log ('H', arr);
}
A ([... a]);
BA]);
C ([... a]);
D ([... a]);
E ([... a]);
F ([... a]);
G ([... a]);
H ([... a]);
Este trecho apresenta apenas o código usado em testes de desempenho - ele não realiza testes por conta própria.
Comparação para navegadores: Chrome v78.0.0, Safari v13.0.4 e Firefox v71.0.0
|
Eu sou muito novo em JavaScript e precisava dessa funcionalidade. Eu simplesmente escrevi isto:
function removeFromArray (array, item, index) {
while ((index = array.indexOf (item))> -1) {
array.splice (índice, 1);
}
}
Então, quando eu quiser usar:
// Configure alguns dados fictícios
var dummyObj = {nome: "meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];
// Remova os dados fictícios
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "item2");
Saída - conforme o esperado.
["item1", "item1"]
Você pode ter necessidades diferentes das minhas, então você pode modificá-lo facilmentepara se adequar a eles. Espero que isso ajude alguém.
|
Se você tiver objetos complexos na matriz, você pode usar filtros?
Em situações em que $ .inArray ou array.splice não é tão fácil de usar. Especialmente se os objetos forem superficiais na matriz.
Por exemplo. se você tiver um objeto com um campo Id e quiser que o objeto seja removido de uma matriz:
this.array = this.array.filter (function (element, i) {
return element.id! == idToRemove;
});
|
Quero responder com base no ECMAScript 6. Suponha que você tenha uma matriz como a abaixo:
deixe arr = [1,2,3,4];
Se você deseja excluir um índice especial como 2, escreva o código abaixo:
arr.splice (2, 1); // => arr tornou-se [1,2,4]
Mas se você deseja excluir um item especial como 3 e não conhece seu índice, faça o seguinte:
arr = arr.filtro (e => e! == 3); // => arr tornou-se [1,2,4]
Dica: use uma função de seta para filtrar o retorno de chamada, a menos que obtenha um array vazio.
|
Atualização: este método é recomendado apenas se você não puder usar o ECMAScript 2015 (anteriormente conhecido como ES6). Se você puder usá-lo, outras respostas aqui fornecem implementações muito mais organizadas.
Essa essência aqui resolverá seu problema e também excluirá todas as ocorrências do argumento em vez de apenas 1 (ou um valor especificado).
Array.prototype.destroy = function (obj) {
// Retorna nulo se nenhum objeto foi encontrado e removido
var destruído = nulo;
para (var i = 0; i  3
x.destroy (false); // => falso
x; // => [1, 2, verdadeiro, indefinido]
x.destroy (verdadeiro); // => verdadeiro
x.destroy (indefinido); // => indefinido
x; // => [1, 2]
x.destroy (3); // => nulo
x; // => [1, 2]
|
Atualização ES10
Esta postagem resume as abordagens comuns para a remoção de elementos da matriz no ECMAScript 2019 (ES10).
1. Casos gerais
1.1. Removendo o elemento Array por valor usando .splice ()
| No local: Sim |
| Remove duplicatas: Sim (loop), Não (indexOf) |
| Por valor / índice: Por índice |
Se você souber o valor que deseja remover de uma matriz, poderá usar o método de emenda. Primeiro você deve identificar o índice do item de destino. Em seguida, você usa o índice como o elemento inicial e remove apenas um elemento.
// Com um loop 'for'
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
para (deixe i = 0; i  [1, 2, 3, 4, 6, 7, 8, 9, 0]
// Com o método .indexOf ()
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Removendo o elemento Array usando o método .filter ()
| No local: Não |
| Remove duplicatas: Sim |
| Por valor / índice: Por valor |
O elemento específico pode ser filtrado da matriz, fornecendo a função de filtragem. Essa função é então chamada para cada elemento do array.
valor const = 3
deixe arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == valor)
console.log (arr)
// [1, 2, 4, 5]
1.3. Removendo o elemento Array estendendo Array.prototype
| No local: Sim / Não (depende da implementação) |
| Remove duplicatas: Sim / Não (Depende da implementação) |
| Por valor / índice: Por índice / Por valor (depende da implementação) |
Prototype of Array pode ser estendido com métodos adicionais. Esses métodos estarão disponíveis para uso em matrizes criadas.
Nota: Estender protótipos de objetos da biblioteca padrão de JavaScript (como Array) é considerado por alguns como um antipadrão.
// No local, remove tudo, por implementação de valor
Array.prototype.remove = function (item) {
para (seja i = 0; i  = ES10)
| No local: Não |
| Remove duplicatas: Sim |
| Por valor / índice: Por valor |
ES10 introduziu Object.fromEntries, que pode serusado para criar o Array desejado a partir de qualquer objeto do tipo Array e filtrar elementos indesejados durante o processo.
objeto const = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values ​​(Object.fromEntries (
Object.entries (objeto)
.filter (([key, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Casos especiais
2.1 Removendo o elemento se estiver no final do Array
2.1.1. Alterando o comprimento do array
| No local: Sim |
| Remove duplicatas: Não |
| Por valor / índice: N / A |
Os elementos do array JavaScript podem ser removidos do final de um array definindo a propriedade length com um valor menor que o valor atual. Qualquer elemento cujo índice seja maior ou igual ao novo comprimento será removido.
const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Defina o comprimento para remover o elemento
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. Usando o método .pop ()
| No local: Sim |
| Remove duplicatas: Não |
| Por valor / índice: N / A |
O método pop remove o último elemento da matriz, retorna esse elemento e atualiza a propriedade length. O método pop modifica a matriz na qual é invocado. Isso significa que, ao contrário do uso de delete, o último elemento é removido completamente e o comprimento da matriz reduzido.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // retorna 6
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Removendo o elemento se estiver no início da matriz
| No local: Sim |
| Remove duplicatas: Não |
| Por valor / índice: N / A |
O método .shift () funciona de maneira muito semelhante ao método pop, exceto que remove o primeiro elemento de uma matriz JavaScript em vez do último. Quando o elemento é removido, os elementos restantes são deslocados para baixo.
arr const = [1, 2, 3, 4];
arr.shift (); // retorna 1
console.log (arr); // [2, 3, 4]
2.3. Removendo elemento se for o único elemento no Array
| No local: Sim |
| Remove duplicatas: N / A |
| Por valor / índice: N / A |
A técnica mais rápida é definir uma variável de array para um array vazio.
deixe arr = [1];
arr = []; // array vazio
Alternativamente, a técnica de 2.1.1 pode ser usada definindo o comprimento como 0.
|
Você nunca deve alterar seu array. Como isso é contra o padrão de programação funcional. Você pode criar uma nova matriz sem fazer referência à matriz cujos dados deseja alterar usando o filtro do método ECMAScript 6;
var meuArray = [1, 2, 3, 4, 5, 6];
Suponha que você queira remover 5 da matriz, você pode simplesmente fazer assim:
meuVetor = meuVetor.filtro (valor => valor! == 5);
Isso lhe dará uma nova matriz sem o valor que você deseja remover. Portanto, o resultado será:
[1, 2, 3, 4, 6]; // 5 foi removido desta matriz
Para melhor compreensão, você pode ler a documentação MDN em Array.filter.
|
Uma abordagem mais moderna, ECMAScript 2015 (anteriormente conhecido como Harmony ou ES 6). Dado:
itens const = [1, 2, 3, 4];
índice const = 2;
Então:
items.filter ((x, i) => i! == index);
Produzindo:
[1, 2, 4]
Você pode usar o Babel e um serviço polyfill para garantir que haja um bom suporte para todos os navegadores.
|
Você pode fazer um loop para trás para ter certeza de não bagunçar os índices, se houver várias instâncias do elemento.
var meuElemento = "chocolate";
var meuArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];
/ * Código importante * /
for (var i = myArray.length - 1; i> = 0; i--) {
if (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (meuVetor);
Demonstração ao vivo
|
Você tem 1 a 9 na matriz e deseja remover 5. Use o código abaixo:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
return m! == 5;
});
console.log ("novo Array, 5 removidos", newNumberArray);
Se você deseja vários valores. Exemplo: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
return (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("novo Array, 1,7 e 8 removidos", newNumberArray);
Se você quiser remover um valor de array em um array. Exemplo: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
return! removebleArray.includes (m);
});
console.log ("novo Array, [3,4,5] removido", newNumberArray);
Inclui o navegador compatível com o link.
|
1
2
3
4
Próximo
Questão altamente ativa. Ganhe 10 reputação para responder a esta pergunta. O requisito de reputação ajuda a proteger essa pergunta contra spam e atividades sem resposta.
Não é a resposta que você está procurando? Navegue por outras questões com matrizes de javascript marcadas ou faça sua própria pergunta.